Scalable Reasoning by Abstraction in DL-Lite

The DL-Lite family are description logics specifically designed for ontology-based data access (OBDA). In this setting, an ontology with background knowlege (a TBox) can be seen as a conceptual view over data repositories (ABoxes), and data can be accessed via query answering services. Common techniques for query answering in DL-Lite are (pure) rewriting and combined approaches. In the rewriting approaches, OBDA systems exploit the background knowledge and rewrite the input query so that the rewritten queries are sufficient to retrieve the complete query answer when evaluated over the unmodified data. Combined approaches complement the pure rewriting approaches; they also work for DL fragments that allow for qualified existential quantification. In contrast to pure rewriting, the combined approaches not only rewrite the input query, but also partially or completely expand the data taking the ontology/schema into account. The latter operation is called data completion or ontology materialization. It plays an important role in the overall performance of the combined approaches, given the fact that the data is often very large in the OBDA applications. Recently, it has been shown that ontologies with large datasets can be efficiently materialized by a so-called abstraction refinement technique, which consists of two phases: the abstraction phase and the refinement phase. In the abstraction phase, individuals in the ABox are partitioned into equivalence classes to construct a so-called abstract ABox. Entailments of the abstract ABox are transformed to entailments for the original ABox, which might result in some individuals no longer belonging to the same equivalence class. Therefore, the previous steps are repeated in the refinement phase, e.g. individuals are re-partitioned, until, eventually, the fixed-point is reached. In this paper, we present an enhancement of the existing abstraction refinement approach tailored towards DL-Lite ontologies. We make the following contributions: – We present an abstraction-based approach for materialization in DL-LiteHt core, an extension of DL-Litecore with role inclusions and disjunctions. The limited form of existential restrictions in DL-Lite enables an efficient way to transform entailments from the abstract ABox to the original ABox. In addition, the presented approach does not require the refinement phase. This allows not only for faster materialization but also for efficient consistency checking of the ontologies. – We show that the presented approach is also sound and complete when adding nominals. Moreover, it can be extended to ontology classification, a non-trivial reasoning task in the presence of nominals. – We evaluate our approach on both real-life and benchmark ontologies. The empirical results demonstrate that the size of the ABoxes can be reduced by orders of magnitude and, as a result, reasoning via abstraction is often much faster than reasoning over the original ontology.